//2024.02.24 16:41 星期六 晴

// 根据 给定的 currentOp 比对 magnetImp 信息 判定 是否 在吸附 区域中

import {
  endsTimeAnimation,
  SetStaticCssTxtFunc,
  settimeNth,
} from '../../../components/aaanewApp/global/global';
import { polygon_intersectPolygon } from '../../TestJS/searchforBigestPolygon/searchforBigestPolygon';
import { settleLightNode } from './settleLightNode';
import { getmagnetImp } from './vMagnet';

// 磁吸元素 所有信息
let etedDataInfo = undefined;

let magLightAnima = SetStaticCssTxtFunc('magenet_lightNodeAnima');

/**
 * 拖动元素的 节选信息
 *
 * 计算 当前 元素的 矩形坐标
 */
let elpoPolygon;

const left = 'left';
const top = 'top';
const width = 'width';
const height = 'height';
// const bottom = 'bottom';
// const right = 'right';

/**
 * 添加 显示 lightNode 元素时 的 延时
 */
const delayDisplayLightNode = 100;

/**
 * 添加 显示 lightNode 元素时 使用的动画
 */
const dispayLightNode = 'dispayLightNode';

/**
 * 移除 lightNode 元素时 使用的动画
 */
const removeLightNode = 'removeLightNode';

let currentDir;

/**
 * 根据 当前元素位置 判定元素 是否 与 吸附区域 是否有交集 给定 交集信息
 *
 * 进行吸附域 判定 -- 深度优先
 * @param {Object} currentOp 当前 元素位置
 * @returns -- 返回 fromto 动画  信息集
 */
function magenetJudgment(currentOp) {
  let returninfo = {
    isover: false,
    fromEl: new HTMLElement(),
    toEl: new HTMLElement(),
  };

  // 更新数据 别太频繁
  //   etedDataInfo = getmagnetImp();
  if (etedDataInfo == undefined || window.updataInfo('magnetImp')) {
    etedDataInfo = getmagnetImp();
  }

  //   console.log(currentOp, etedDataInfo);
  // 计算 当前 元素的 矩形坐标
  elpoPolygon = getElPolygon(currentOp);

  //   拖动元素的 id
  let elID = currentOp['elID'];

  let isOver = checkOverArea(elID, currentOp);

  if (isOver['dirction'] != undefined) {
    OverFuncAnima(isOver, currentOp);
    returninfo.isover = true;
    returninfo.fromEl = document.getElementById(elID);
    returninfo.toEl = isOver['node'];
  } else {
    isOver = checkOverArea('global');
    if (isOver['dirction'] != undefined) {
      if (currentDir != isOver['dirction']) {
        console.log(
          'current Dirction is :',
          isOver['dirction'],
          ', el is :',
          isOver['elID'],
          ', elpo :',
          isOver['elpo'],
          ', dirArea :',
          isOver['dirArea']
        );
        currentDir = isOver['dirction'];
        console.log('newbee');
      }
    }
  }
  return returninfo;
}

/**
 * 根据 相关 信息集 计算出 该元素的 四边点位信息
 * @param {Object} currentOp 大致 可以计算出 元素点位的 信息集
 */
function getElPolygon(currentOp) {
  let copPolygonArr = [
    [currentOp[left], currentOp[top]],
    [currentOp[left] + currentOp[width], currentOp[top]],
    [currentOp[left] + currentOp[width], currentOp[top] + currentOp[height]],
    [currentOp[left], currentOp[top] + currentOp[height]],
    [currentOp[left], currentOp[top]],
  ];
  //   console.log(copPolygonArr);
  return copPolygonArr;
}

function checkOverArea(elID, currentOp) {
  //   返回信息
  let returninfo = {
    dirction: new String(),
    elID: new String(),
    elpoPolygon: undefined,
    elpo: undefined,
    dirArea: undefined,
    magnetID: new String(),
    magnetElpo: undefined,
    node: new HTMLElement(),
  };

  // 单元 磁吸元素 ID
  let magnet_id;

  // 单元 磁吸元素 信息
  let magnet_i;

  if (etedDataInfo[elID] == undefined) {
    return returninfo;
  }
  //   对拖动元素 进行吸附域 判定 -- 深度优先
  for (let i = 0; i < etedDataInfo[elID]['data'].length; i++) {
    magnet_id = etedDataInfo[elID]['data'][i];
    magnet_i = etedDataInfo[elID][magnet_id];
    // console.log(magnet_i);
    // 检测 拖动元素 是否在 当前选定的 吸附域 内
    const overBigArea = polygon_intersectPolygon(
      elpoPolygon,
      magnet_i['bigReflectArea']
    );

    // 如果 在 当前 选定的吸附域内 进行深度 检测 并返回相关信息
    if (overBigArea) {
      for (let i = 0; i < magnet_i['poiArea'].length; i++) {
        const direc_i = magnet_i['poiArea'][i];

        const dir_i_over = polygon_intersectPolygon(
          elpoPolygon,
          magnet_i[direc_i]['polygonArr']
        );

        if (dir_i_over) {
          // isOver['magnetElpo'] = isOver['elpo'];
          // isOver['elpo'] = {
          //   top: currentOp[top],
          //   left: currentOp[left],
          //   width: currentOp[width],
          //   height: currentOp[height],
          // };
          returninfo['elpoPolygon'] = elpoPolygon;
          //   returninfo['elpo'] = magnet_i['elpo'];
          returninfo['elpo'] = {
            top: currentOp[top],
            left: currentOp[left],
            width: currentOp[width],
            height: currentOp[height],
          };
          returninfo['magnetElpo'] = magnet_i['elpo'];

          returninfo['dirArea'] = magnet_i[direc_i]['polygonArr'];
          returninfo['dirction'] = direc_i;
          returninfo['magnetID'] = magnet_id;
          returninfo['elID'] = elID;

          return returninfo;
        }
      }
      return returninfo;
    }
  }
  return returninfo;
}

/**
 * 将高亮元素 放置到 页面 默认添加到 body 元素的 的 尾部
 * @param {Object} lightNode 高亮元素
 */
function improveLightNodeToDoc(lightNode) {
  document.body.appendChild(lightNode);
}

function lightNodeAnimaStaticCss() {
  magLightAnima(dispayLightNode, '');
  magLightAnima(removeLightNode, '');
}
lightNodeAnimaStaticCss();

function OverFuncAnima(isOver) {
  // if (currentDir != isOver['dirction']) {
  //   console.log(
  //     'current Dirction is :',
  //     isOver['dirction'],
  //     ', el is :',
  //     isOver['elID'],
  //     ', elpo :',
  //     isOver['elpo'],
  //     ', dirArea :',
  //     isOver['dirArea']
  //   );
  //   currentDir = isOver['dirction'];
  //   console.log('newbee');
  // }
  //   isOver['magnetElpo'] = isOver['elpo'];
  //   isOver['elpo'] = {
  //     top: currentOp[top],
  //     left: currentOp[left],
  //     width: currentOp[width],
  //     height: currentOp[height],
  //   };
  console.log('over', isOver['dirction']);
  /**
   * 获取 返回 lightNode 信息集
   */
  let lightNodeInf = settleLightNode(isOver);

  if (lightNodeInf['hasChangedNode']) {
    let afterT;
    // 当 上一个 lightNode 不为 空时
    if (lightNodeInf['lastNode'] != undefined) {
      // lightNodeInf['lastNode']
      // 在 消失动画 结束后 删除该元素
      afterT = endsTimeAnimation(lightNodeInf['lastNode'], removeLightNode);
      settimeNth([0, afterT], () => {
        lightNodeInf['lastNode'].remove();
      });
    }

    settimeNth([0, afterT], () => {
      improveLightNodeToDoc(lightNodeInf['node']);

      endsTimeAnimation(
        lightNodeInf['node'],
        dispayLightNode,
        delayDisplayLightNode
      );
    });
  }
}

export { magenetJudgment };
